package xfsale.web.service.impl;

import xfsale.packet.TAAcctCancelRequest;
import xfsale.packet.TAAcctCancelResponse;
import xfsale.packet.TAAcctOpenRequest;
import xfsale.packet.TAAcctOpenResponse;
import xfsale.packet.TAAcctRegisterRequest;
import xfsale.packet.TAAcctRegisterResponse;
import xfsale.packet.TransAcctCancelRequest;
import xfsale.packet.TransAcctCancelResponse;
import xfsale.packet.TransAcctFreezeRequest;
import xfsale.packet.TransAcctFreezeResponse;
import xfsale.packet.TransAcctOpenRequest;
import xfsale.packet.TransAcctOpenResponse;
import xfsale.packet.TransAcctPassModRequest;
import xfsale.packet.TransAcctPassModResponse;
import xfsale.packet.TransAcctPassSetRequest;
import xfsale.packet.TransAcctPassSetResponse;
import xfsale.packet.TransAcctUnfreezeRequest;
import xfsale.packet.TransAcctUnfreezeResponse;
import xfsale.packet.TransAcctUnlockRequest;
import xfsale.packet.TransAcctUnlockResponse;
import xfsale.service.impl.j2ee.TAAcctCancel;
import xfsale.service.impl.j2ee.TAAcctOpen;
import xfsale.service.impl.j2ee.TAAcctRegister;
import xfsale.service.impl.j2ee.TransAcctCancel;
import xfsale.service.impl.j2ee.TransAcctFreeze;
import xfsale.service.impl.j2ee.TransAcctOpen;
import xfsale.service.impl.j2ee.TransAcctPassMod;
import xfsale.service.impl.j2ee.TransAcctPassSet;
import xfsale.service.impl.j2ee.TransAcctUnfreeze;
import xfsale.service.impl.j2ee.TransAcctUnlock;
import xfsale.web.service.OrderService;

@SuppressWarnings("CallToThreadDumpStack")
public final class OrderServiceImpl implements OrderService {

    @Override
    public TAAcctCancelResponse doTAAcctCancel(TAAcctCancelRequest request) {
        TAAcctCancelResponse response = new TAAcctCancelResponse();

        try {
            TAAcctCancel order = new TAAcctCancel(request, response);
            order.execute();
        } catch (Exception e) {
            e.printStackTrace();
        }

        return response;
    }

    @Override
    public TAAcctOpenResponse doTAAcctOpen(TAAcctOpenRequest request) {
        TAAcctOpenResponse response = new TAAcctOpenResponse();

        try {
            TAAcctOpen order = new TAAcctOpen(request, response);
            order.execute();
        } catch (Exception e) {
            e.printStackTrace();
        }

        return response;
    }

    @Override
    public TAAcctRegisterResponse doTAAcctRegister(TAAcctRegisterRequest request) {
        TAAcctRegisterResponse response = new TAAcctRegisterResponse();

        try {
            TAAcctRegister order = new TAAcctRegister(request, response);
            order.execute();
        } catch (Exception e) {
            e.printStackTrace();
        }

        return response;
    }

    @Override
    public TransAcctFreezeResponse doTransAcctFreeze(TransAcctFreezeRequest request) {
        TransAcctFreezeResponse response = new TransAcctFreezeResponse();

        try {
            TransAcctFreeze order = new TransAcctFreeze(request, response);
            order.execute();
        } catch (Exception e) {
            e.printStackTrace();
        }

        return response;
    }

    /*
    @Override
    public TransAcctModIdResponse doTransAcctModId(TransAcctModIdRequest request) {
    TransAcctModIdResponse response = new TransAcctModIdResponse();

    try {
    TransAcctModId order = new TransAcctModId(request, response);
    order.execute();
    } catch (Exception e) {
    e.printStackTrace();
    }

    return response;
    }

    @Override
    public TransAcctModRealResponse doTransAcctModReal(TransAcctModRealRequest request) {
    TransAcctModRealResponse response = new TransAcctModRealResponse();

    try {
    TransAcctModReal order = new TransAcctModReal(request, response);
    order.execute();
    } catch (Exception e) {
    e.printStackTrace();
    }

    return response;
    }*/
    @Override
    public TransAcctOpenResponse doTransAcctOpen(TransAcctOpenRequest request) {
        TransAcctOpenResponse response = new TransAcctOpenResponse();

        try {
            TransAcctOpen order = new TransAcctOpen(request, response);
            order.execute();
        } catch (Exception e) {
            e.printStackTrace();
        }

        return response;
    }

    @Override
    public TransAcctCancelResponse doTransAcctCancel(TransAcctCancelRequest request) {
        TransAcctCancelResponse response = new TransAcctCancelResponse();

        try {
            TransAcctCancel order = new TransAcctCancel(request, response);
            order.execute();
        } catch (Exception e) {
            e.printStackTrace();
        }

        return response;
    }

    @Override
    public TransAcctPassModResponse doTransAcctPassMod(TransAcctPassModRequest request) {
        TransAcctPassModResponse response = new TransAcctPassModResponse();

        try {
            TransAcctPassMod order = new TransAcctPassMod(request, response);
            order.execute();
        } catch (Exception e) {
            e.printStackTrace();
        }

        return response;
    }

    @Override
    public TransAcctPassSetResponse doTransAcctPassSet(TransAcctPassSetRequest request) {
        TransAcctPassSetResponse response = new TransAcctPassSetResponse();

        try {
            TransAcctPassSet order = new TransAcctPassSet(request, response);
            order.execute();
        } catch (Exception e) {
            e.printStackTrace();
        }

        return response;
    }

    @Override
    public TransAcctUnfreezeResponse doTransAcctUnfreeze(TransAcctUnfreezeRequest request) {
        TransAcctUnfreezeResponse response = new TransAcctUnfreezeResponse();

        try {
            TransAcctUnfreeze order = new TransAcctUnfreeze(request, response);
            order.execute();
        } catch (Exception e) {
            e.printStackTrace();
        }

        return response;
    }

    @Override
    public TransAcctUnlockResponse doTransAcctUnlock(TransAcctUnlockRequest request) {
        TransAcctUnlockResponse response = new TransAcctUnlockResponse();

        try {
            TransAcctUnlock order = new TransAcctUnlock(request, response);
            order.execute();
        } catch (Exception e) {
            e.printStackTrace();
        }

        return response;
    }
}
